const Service = require('egg').Service;
const fs = require('fs');
const path = require('path');

class UploadService extends Service {
    // 上传头像（保持原有逻辑）
    async uploadAvatar(fileStream, userId) {
        const { ctx, app } = this;

        console.log('开始上传头像，用户ID:', userId);

        // 确保上传目录存在
        const uploadDir = app.config.upload.avatarDir;
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
            console.log('创建头像上传目录:', uploadDir);
        }

        // 生成文件名：用户ID_时间戳.扩展名
        const ext = path.extname(fileStream.filename);
        const filename = `avatar_${userId}_${Date.now()}${ext}`;
        const targetPath = path.join(uploadDir, filename);

        console.log('目标文件路径:', targetPath);

        try {
            // 读取临时文件内容
            const fileContent = fs.readFileSync(fileStream.filepath);

            // 写入目标文件
            fs.writeFileSync(targetPath, fileContent);

            console.log('头像文件保存成功:', targetPath);

            // 生成完整访问URL
            const avatarUrl = `${app.config.upload.avatarBaseUrl}${filename}`;
            console.log('生成的头像URL:', avatarUrl);

            return avatarUrl;
        } catch (error) {
            console.error('头像上传失败:', error);
            throw new Error(`头像上传失败: ${error.message}`);
        } finally {
            // 清理临时文件
            try {
                fs.unlinkSync(fileStream.filepath);
                console.log('临时文件已清理:', fileStream.filepath);
            } catch (e) {
                console.error('清理临时文件失败:', e);
            }
        }
    }

    // 上传帖子图片
    async uploadPostImage(fileStream, userId) {
        const { ctx, app } = this;

        console.log('开始上传帖子图片，用户ID:', userId);

        // 确保帖子图片上传目录存在
        const uploadDir = app.config.upload.postImageDir;
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
            console.log('创建帖子图片上传目录:', uploadDir);
        }

        // 生成文件名：post_用户ID_时间戳.扩展名
        const ext = path.extname(fileStream.filename);
        const filename = `post_${userId}_${Date.now()}${ext}`;
        const targetPath = path.join(uploadDir, filename);

        console.log('目标文件路径:', targetPath);

        try {
            // 读取临时文件内容
            const fileContent = fs.readFileSync(fileStream.filepath);

            // 写入目标文件
            fs.writeFileSync(targetPath, fileContent);

            console.log('帖子图片保存成功:', targetPath);

            // 生成完整访问URL
            const imageUrl = `${app.config.upload.postImageBaseUrl}${filename}`;
            console.log('生成的帖子图片URL:', imageUrl);

            return imageUrl;
        } catch (error) {
            console.error('帖子图片上传失败:', error);
            throw new Error(`图片上传失败: ${error.message}`);
        } finally {
            // 清理临时文件
            try {
                fs.unlinkSync(fileStream.filepath);
                console.log('临时文件已清理:', fileStream.filepath);
            } catch (e) {
                console.error('清理临时文件失败:', e);
            }
        }
    }

    // 上传圈子帖子图片
    async uploadCirclePostImage(fileStream, userId, circleId) {
        const { ctx, app } = this;

        console.log('开始上传圈子帖子图片，用户ID:', userId, '圈子ID:', circleId);

        // 确保圈子帖子图片上传目录存在
        const uploadDir = app.config.upload.circlePostImageDir;
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
            console.log('创建圈子帖子图片上传目录:', uploadDir);
        }

        // 生成文件名：circle_post_用户ID_圈子ID_时间戳.扩展名
        const ext = path.extname(fileStream.filename);
        const filename = `circle_post_${userId}_${circleId}_${Date.now()}${ext}`;
        const targetPath = path.join(uploadDir, filename);

        console.log('目标文件路径:', targetPath);

        try {
            // 读取临时文件内容
            const fileContent = fs.readFileSync(fileStream.filepath);

            // 写入目标文件
            fs.writeFileSync(targetPath, fileContent);

            console.log('圈子帖子图片保存成功:', targetPath);

            // 生成完整访问URL
            const imageUrl = `${app.config.upload.circlePostImageBaseUrl}${filename}`;
            console.log('生成的圈子帖子图片URL:', imageUrl);

            return imageUrl;
        } catch (error) {
            console.error('圈子帖子图片上传失败:', error);
            throw new Error(`图片上传失败: ${error.message}`);
        } finally {
            // 清理临时文件
            try {
                fs.unlinkSync(fileStream.filepath);
                console.log('临时文件已清理:', fileStream.filepath);
            } catch (e) {
                console.error('清理临时文件失败:', e);
            }
        }
    }

    // 删除旧头像文件
    async deleteOldAvatar(avatarUrl) {
        const { ctx, app } = this;

        if (!avatarUrl) return;

        try {
            // 从URL中提取文件名
            const filename = avatarUrl.split('/').pop();
            const filePath = path.join(app.config.upload.avatarDir, filename);

            console.log('尝试删除旧头像:', filePath);

            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
                console.log('旧头像删除成功');
            } else {
                console.log('旧头像文件不存在:', filePath);
            }
        } catch (error) {
            console.error('删除旧头像失败:', error);
        }
    }

    // 删除帖子图片
    async deletePostImage(imageUrl) {
        const { ctx, app } = this;

        if (!imageUrl) return;

        try {
            // 从URL中提取文件名
            const filename = imageUrl.split('/').pop();
            const filePath = path.join(app.config.upload.postImageDir, filename);

            console.log('尝试删除帖子图片:', filePath);

            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
                console.log('帖子图片删除成功');
            } else {
                console.log('帖子图片文件不存在:', filePath);
            }
        } catch (error) {
            console.error('删除帖子图片失败:', error);
        }
    }

    // 删除圈子帖子图片
    async deleteCirclePostImage(imageUrl) {
        const { ctx, app } = this;

        if (!imageUrl) return;

        try {
            // 从URL中提取文件名
            const filename = imageUrl.split('/').pop();
            const filePath = path.join(app.config.upload.circlePostImageDir, filename);

            console.log('尝试删除圈子帖子图片:', filePath);

            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
                console.log('圈子帖子图片删除成功');
            } else {
                console.log('圈子帖子图片文件不存在:', filePath);
            }
        } catch (error) {
            console.error('删除圈子帖子图片失败:', error);
        }
    }

    // 在 UploadService 类中添加以下方法
    async uploadResumeImage(fileStream, userId) {
        const { ctx, app } = this;

        console.log('开始上传简历图片，用户ID:', userId);

        // 确保简历图片上传目录存在
        const uploadDir = app.config.upload.resumeImageDir; // 需要在配置中新增该目录
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
            console.log('创建简历图片上传目录:', uploadDir);
        }

        // 生成文件名：resume_用户ID_时间戳.扩展名
        const ext = path.extname(fileStream.filename);
        const filename = `resume_${userId}_${Date.now()}${ext}`;
        const targetPath = path.join(uploadDir, filename);

        console.log('目标文件路径:', targetPath);

        try {
            // 读取临时文件内容
            const fileContent = fs.readFileSync(fileStream.filepath);

            // 写入目标文件
            fs.writeFileSync(targetPath, fileContent);

            console.log('简历图片保存成功:', targetPath);

            // 生成完整访问URL（需要在配置中新增基础URL）
            const imageUrl = `${app.config.upload.resumeImageBaseUrl}${filename}`;
            console.log('生成的简历图片URL:', imageUrl);

            return imageUrl;
        } catch (error) {
            console.error('简历图片上传失败:', error);
            throw new Error(`简历图片上传失败: ${error.message}`);
        } finally {
            // 清理临时文件
            try {
                fs.unlinkSync(fileStream.filepath);
                console.log('临时文件已清理:', fileStream.filepath);
            } catch (e) {
                console.error('清理临时文件失败:', e);
            }
        }
    }

    // 上传商品图片 - 使用配置的路径
    async uploadGoodImage(fileStream, userId) {
        const { ctx, app } = this;

        console.log('开始上传商品图片，用户ID:', userId);

        // 使用配置的路径
        const uploadDir = app.config.upload.goodImageDir;

        // 确保上传目录存在
        if (!fs.existsSync(uploadDir)) {
            fs.mkdirSync(uploadDir, { recursive: true });
            console.log('创建商品图片上传目录:', uploadDir);
        }

        console.log('使用上传目录:', uploadDir);

        // 生成文件名：good_用户ID_时间戳_随机数.扩展名
        const ext = path.extname(fileStream.filename).toLowerCase();
        const random = Math.random().toString(36).substr(2, 8);
        const filename = `good_${userId}_${Date.now()}_${random}${ext}`;
        const targetPath = path.join(uploadDir, filename);

        console.log('目标文件路径:', targetPath);

        try {
            // 验证文件类型
            const allowedTypes = ['.jpg', '.jpeg', '.png', '.gif', '.webp'];
            if (!allowedTypes.includes(ext)) {
                throw new Error('不支持的文件格式，仅支持 JPG、PNG、GIF、WebP 格式');
            }

            // 验证文件大小（最大 5MB）
            const maxSize = 5 * 1024 * 1024;
            const fileStats = fs.statSync(fileStream.filepath);
            if (fileStats.size > maxSize) {
                throw new Error('文件大小不能超过 5MB');
            }

            // 读取临时文件内容
            const fileContent = fs.readFileSync(fileStream.filepath);

            // 写入目标文件
            fs.writeFileSync(targetPath, fileContent);

            console.log('商品图片保存成功:', targetPath);

            // 生成访问URL - 使用配置的基础URL
            const imageUrl = `${app.config.upload.goodImageBaseUrl}${filename}`;
            console.log('生成的商品图片URL:', imageUrl);

            return {
                url: imageUrl,
                filename: filename,
                size: fileStats.size,
                mimetype: this.getMimeType(ext)
            };
        } catch (error) {
            console.error('商品图片上传失败:', error);
            throw new Error(`图片上传失败: ${error.message}`);
        } finally {
            // 清理临时文件
            try {
                fs.unlinkSync(fileStream.filepath);
                console.log('临时文件已清理:', fileStream.filepath);
            } catch (e) {
                console.error('清理临时文件失败:', e);
            }
        }
    }

    // 上传多张商品图片
    async uploadMultipleGoodImages(fileStreams, userId) {
        const results = [];

        for (const fileStream of fileStreams) {
            try {
                const result = await this.uploadGoodImage(fileStream, userId);
                results.push(result);
            } catch (error) {
                console.error(`上传图片 ${fileStream.filename} 失败:`, error);
                results.push({
                    filename: fileStream.filename,
                    error: error.message,
                    success: false
                });
            }
        }

        return results;
    }

    // 删除商品图片 - 使用配置的路径
    async deleteGoodImage(imageUrl) {
        const { ctx, app } = this;

        if (!imageUrl) return;

        try {
            // 从URL中提取文件名
            const filename = imageUrl.split('/').pop();
            const uploadDir = app.config.upload.goodImageDir;
            const filePath = path.join(uploadDir, filename);

            console.log('尝试删除商品图片:', filePath);

            if (fs.existsSync(filePath)) {
                fs.unlinkSync(filePath);
                console.log('商品图片删除成功');
                return true;
            } else {
                console.log('商品图片文件不存在:', filePath);
                return false;
            }
        } catch (error) {
            console.error('删除商品图片失败:', error);
            throw new Error(`删除图片失败: ${error.message}`);
        }
    }

    // 批量删除商品图片
    async deleteMultipleGoodImages(imageUrls) {
        const results = [];

        for (const imageUrl of imageUrls) {
            try {
                const success = await this.deleteGoodImage(imageUrl);
                results.push({
                    url: imageUrl,
                    success: success
                });
            } catch (error) {
                results.push({
                    url: imageUrl,
                    success: false,
                    error: error.message
                });
            }
        }

        return results;
    }

    // 辅助方法：根据扩展名获取MIME类型
    getMimeType(ext) {
        const mimeTypes = {
            '.jpg': 'image/jpeg',
            '.jpeg': 'image/jpeg',
            '.png': 'image/png',
            '.gif': 'image/gif',
            '.webp': 'image/webp'
        };
        return mimeTypes[ext] || 'application/octet-stream';
    }

    async uploadBannerImage(file) {
        const { app } = this;
        const fs = require('fs');
        const path = require('path');

        try {
            // 生成唯一文件名
            const ext = path.extname(file.filename);
            const timestamp = Date.now();
            const randomStr = Math.random().toString(36).substring(2, 8);
            const filename = `banner_${timestamp}_${randomStr}${ext}`;

            // 轮播图存储目录
            const targetDir = path.join(app.baseDir, 'app/public/uploads/banners');

            // 确保目录存在
            if (!fs.existsSync(targetDir)) {
                fs.mkdirSync(targetDir, { recursive: true });
            }

            const targetPath = path.join(targetDir, filename);

            // 读取临时文件并写入目标位置
            const fileData = await fs.promises.readFile(file.filepath);
            await fs.promises.writeFile(targetPath, fileData);

            // 删除临时文件
            await fs.promises.unlink(file.filepath);

            // 返回访问URL - 根据您的实际域名配置调整
            const fileUrl = `/public/uploads/banners/${filename}`;

            console.log('轮播图保存成功:', fileUrl);
            return fileUrl;

        } catch (error) {
            console.error('轮播图保存失败:', error);

            // 确保删除临时文件
            try {
                await fs.promises.unlink(file.filepath);
            } catch (e) {
                // ignore
            }

            throw new Error('轮播图保存失败');
        }
    }
}

module.exports = UploadService;